home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / newmdct.c < prev    next >
C/C++ Source or Header  |  2000-01-01  |  20KB  |  697 lines
  1. /*
  2.  *    MP3 window subband -> subband filtering -> mdct routine
  3.  *
  4.  *    Copyright (c) 1999 Takehiro TOMINAGA
  5.  *
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Library General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  15.  * Library General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Library General Public
  18.  * License along with this library; if not, write to the
  19.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20.  * Boston, MA 02111-1307, USA.
  21.  */
  22.  
  23. /*
  24.  *         Special Thanks to Patrick De Smet for your advices.
  25.  */
  26.  
  27.  
  28. #include "util.h"
  29. #include "l3side.h"
  30. #include "newmdct.h"
  31.  
  32. #define SCALE 32768
  33.  
  34. static const FLOAT8 enwindow[] = 
  35. {
  36.   3.5758972e-02, 3.401756e-03,  9.83715e-04,   9.9182e-05,
  37.       -4.77e-07,  1.03951e-04,  9.53674e-04, 2.841473e-03,
  38.      1.2398e-05,  1.91212e-04, 2.283096e-03,1.6994476e-02,
  39.   1.8756866e-02, 2.630711e-03,  2.47478e-04,   1.4782e-05,
  40.  
  41.   3.5694122e-02, 3.643036e-03,  9.91821e-04,   9.6321e-05,
  42.       -4.77e-07,  1.05858e-04,  9.30786e-04, 2.521515e-03,
  43.      1.1444e-05,  1.65462e-04, 2.110004e-03,1.6112804e-02,
  44.   1.9634247e-02, 2.803326e-03,  2.77042e-04,   1.6689e-05,
  45.  
  46.   3.5586357e-02, 3.858566e-03,  9.95159e-04,   9.3460e-05,
  47.       -4.77e-07,  1.07288e-04,  9.02653e-04, 2.174854e-03,
  48.      1.0014e-05,  1.40190e-04, 1.937389e-03,1.5233517e-02,
  49.   2.0506859e-02, 2.974033e-03,  3.07560e-04,   1.8120e-05,
  50.  
  51.   3.5435200e-02, 4.049301e-03,  9.94205e-04,   9.0599e-05,
  52.       -4.77e-07,  1.08242e-04,  8.68797e-04, 1.800537e-03,
  53.       9.060e-06,  1.16348e-04, 1.766682e-03,1.4358521e-02,
  54.   2.1372318e-02,  3.14188e-03,  3.39031e-04,   1.9550e-05,
  55.  
  56.   3.5242081e-02, 4.215240e-03,  9.89437e-04,   8.7261e-05,
  57.       -4.77e-07,  1.08719e-04,  8.29220e-04, 1.399517e-03,
  58.       8.106e-06,   9.3937e-05, 1.597881e-03,1.3489246e-02,
  59.   2.2228718e-02, 3.306866e-03,  3.71456e-04,   2.1458e-05,
  60.  
  61.   3.5007000e-02, 4.357815e-03,  9.80854e-04,   8.3923e-05,
  62.       -4.77e-07,  1.08719e-04,   7.8392e-04,  9.71317e-04,
  63.       7.629e-06,   7.2956e-05, 1.432419e-03,1.2627602e-02,
  64.   2.3074150e-02, 3.467083e-03,  4.04358e-04,   2.3365e-05,
  65.  
  66.   3.4730434e-02, 4.477024e-03,  9.68933e-04,   8.0585e-05,
  67.       -9.54e-07,  1.08242e-04,  7.31945e-04,  5.15938e-04,
  68.       6.676e-06,   5.2929e-05, 1.269817e-03,1.1775017e-02,
  69.   2.3907185e-02, 3.622532e-03,  4.38213e-04,   2.5272e-05,
  70.  
  71.   3.4412861e-02, 4.573822e-03,  9.54151e-04,   7.6771e-05,
  72.       -9.54e-07,  1.06812e-04,  6.74248e-04,   3.3379e-05,
  73.       6.199e-06,   3.4332e-05, 1.111031e-03,1.0933399e-02,
  74.   2.4725437e-02, 3.771782e-03,  4.72546e-04,   2.7657e-05,
  75.  
  76.   3.4055710e-02, 4.649162e-03,  9.35555e-04,   7.3433e-05,
  77.       -9.54e-07,  1.05381e-04,  6.10352e-04, -4.75883e-04,
  78.       5.245e-06,   1.7166e-05,  9.56535e-04,1.0103703e-02,
  79.   2.5527000e-02, 3.914356e-03,  5.07355e-04,   3.0041e-05,
  80.  
  81.   3.3659935e-02, 4.703045e-03,  9.15051e-04,   7.0095e-05,
  82.       -9.54e-07,  1.02520e-04,  5.39303e-04,-1.011848e-03,
  83.       4.768e-06,     9.54e-07,  8.06808e-04, 9.287834e-03,
  84.   2.6310921e-02, 4.048824e-03,  5.42164e-04,   3.2425e-05,
  85.  
  86.   3.3225536e-02, 4.737377e-03,  8.91685e-04,   6.6280e-05,
  87.      -1.431e-06,   9.9182e-05,  4.62532e-04,-1.573563e-03,
  88.       4.292e-06,  -1.3828e-05,  6.61850e-04, 8.487225e-03,
  89.   2.7073860e-02, 4.174709e-03,  5.76973e-04,   3.4809e-05,
  90.  
  91.   3.2754898e-02, 4.752159e-03,  8.66413e-04,   6.2943e-05,
  92.      -1.431e-06,   9.5367e-05,  3.78609e-04,-2.161503e-03,
  93.       3.815e-06,   -2.718e-05,  5.22137e-04, 7.703304e-03,
  94.   2.7815342e-02, 4.290581e-03,  6.11782e-04,   3.7670e-05,
  95.  
  96.   3.2248020e-02, 4.748821e-03,  8.38757e-04,   5.9605e-05,
  97.      -1.907e-06,   9.0122e-05,  2.88486e-04,-2.774239e-03,
  98.       3.338e-06,  -3.9577e-05,  3.88145e-04, 6.937027e-03,
  99.   2.8532982e-02, 4.395962e-03,  6.46591e-04,   4.0531e-05,
  100.  
  101.   3.1706810e-02, 4.728317e-03,  8.09669e-04,    5.579e-05,
  102.      -1.907e-06,   8.4400e-05,  1.91689e-04,-3.411293e-03,
  103.       3.338e-06,  -5.0545e-05,  2.59876e-04, 6.189346e-03,
  104.   2.9224873e-02, 4.489899e-03,  6.80923e-04,   4.3392e-05,
  105.  
  106.   3.1132698e-02, 4.691124e-03,  7.79152e-04,   5.2929e-05,
  107.      -2.384e-06,   7.7724e-05,   8.8215e-05,-4.072189e-03,
  108.       2.861e-06,  -6.0558e-05,  1.37329e-04, 5.462170e-03,
  109.   2.9890060e-02, 4.570484e-03,  7.14302e-04,   4.6253e-05,
  110.  
  111.   3.5780907e-02,1.7876148e-02,3.134727e-03,2.457142e-03,
  112.     9.71317e-04,  2.18868e-04, 1.01566e-04,  1.3828e-05,
  113.  
  114.   3.0526638e-02, 4.638195e-03,  7.47204e-04,   4.9591e-05,
  115.    4.756451e-03,   2.1458e-05,  -6.9618e-05,    2.384e-06
  116. };
  117.  
  118.  
  119. #define NS 12
  120. #define NL 36
  121.  
  122. static FLOAT8 ca[8], cs[8];
  123. static FLOAT8 win[4][36];
  124. static FLOAT8 tantab_l[NL/4];
  125. static FLOAT8 tritab_s[NS/4*2];
  126.  
  127. /************************************************************************
  128. *
  129. * window_subband()
  130. *
  131. * PURPOSE:  Overlapping window on PCM samples
  132. *
  133. * SEMANTICS:
  134. * 32 16-bit pcm samples are scaled to fractional 2's complement and
  135. * concatenated to the end of the window buffer #x#. The updated window
  136. * buffer #x# is then windowed by the analysis window #c# to produce the
  137. * windowed sample #z#
  138. *
  139. ************************************************************************/
  140.  
  141. /*
  142.  *      new IDCT routine written by Naoki Shibata
  143.  */
  144. INLINE static void idct32(FLOAT8 a[])
  145. {
  146.     /* returns sum_j=0^31 a[j]*cos(PI*j*(k+1/2)/32), 0<=k<32 */
  147.  
  148.     static const FLOAT8 costab[] = {
  149.     0.54119610014619701222,
  150.     1.3065629648763763537,
  151.  
  152.     0.50979557910415917998,
  153.     2.5629154477415054814,
  154.     0.89997622313641556513,
  155.     0.60134488693504528634,
  156.  
  157.     0.5024192861881556782,
  158.     5.1011486186891552563,
  159.     0.78815462345125020249,
  160.     0.64682178335999007679,
  161.     0.56694403481635768927,
  162.     1.0606776859903470633,
  163.     1.7224470982383341955,
  164.     0.52249861493968885462,
  165.  
  166.     10.19000812354803287,
  167.     0.674808341455005678,
  168.     1.1694399334328846596,
  169.     0.53104259108978413284,    
  170.     2.0577810099534108446,
  171.     0.58293496820613388554,
  172.     0.83934964541552681272,
  173.     0.50547095989754364798,
  174.     3.4076084184687189804,
  175.     0.62250412303566482475,
  176.     0.97256823786196078263,
  177.     0.51544730992262455249,
  178.     1.4841646163141661852,
  179.     0.5531038960344445421,
  180.     0.74453627100229857749,
  181.     0.5006029982351962726,
  182.     };
  183.  
  184.     int i;
  185.  
  186.     a[31] += a[29]; a[29] += a[27];
  187.     a[27] += a[25]; a[25] += a[23];
  188.     a[23] += a[21]; a[21] += a[19];
  189.     a[19] += a[17]; a[17] += a[15];
  190.     a[15] += a[13]; a[13] += a[11];
  191.     a[11] += a[ 9]; a[ 9] += a[ 7];
  192.     a[ 7] += a[ 5]; a[ 5] += a[ 3];
  193.     a[ 3] += a[ 1];
  194.  
  195.     a[31] += a[27]; a[27] += a[23];
  196.     a[30] += a[26]; a[26] += a[22];
  197.     a[23] += a[19]; a[19] += a[15];
  198.     a[22] += a[18]; a[18] += a[14];
  199.     a[15] += a[11]; a[11] += a[ 7];
  200.     a[14] += a[10]; a[10] += a[ 6];
  201.     a[ 7] += a[ 3];
  202.     a[ 6] += a[ 2];
  203.  
  204.     a[31] += a[23]; a[23] += a[15];    a[15] += a[ 7];
  205.     a[30] += a[22]; a[22] += a[14];    a[14] += a[ 6];
  206.     a[29] += a[21]; a[21] += a[13];    a[13] += a[ 5];
  207.     a[28] += a[20]; a[20] += a[12];    a[12] += a[ 4];
  208.  
  209.     a[ 6] = -a[ 6];    a[22] = -a[22];
  210.     a[12] = -a[12];    a[28] = -a[28];
  211.     a[13] = -a[13];    a[29] = -a[29];
  212.     a[15] = -a[15];    a[31] = -a[31];
  213.     a[ 3] = -a[ 3];    a[19] = -a[19];
  214.     a[11] = -a[11];    a[27] = -a[27];
  215.  
  216.     {
  217.     FLOAT8 const *xp = costab;
  218.     int p0,p1;
  219.     for (i = 0; i < 8; i++) {
  220.         FLOAT8 x1, x2, x3, x4;
  221.  
  222.         x3 = a[i+16] * (SQRT2*0.5);
  223.         x4 = a[i] - x3;
  224.         x3 = a[i] + x3;
  225.  
  226.         x2 = -(a[24+i] + a[i+8]) * (SQRT2*0.5);
  227.         x1 = (a[i+8] - x2) * xp[0];
  228.         x2 = (a[i+8] + x2) * xp[1];
  229.  
  230.         a[i   ] = x3 + x1;
  231.         a[i+ 8] = x4 - x2;
  232.         a[i+16] = x4 + x2;
  233.         a[i+24] = x3 - x1;
  234.     }
  235.  
  236.     xp += 2;
  237.  
  238.     for (i = 0; i < 4; i++) {
  239.         FLOAT8 xr;
  240.  
  241.         xr = a[i+28] * xp[0];
  242.         a[i+28] = (a[i] - xr);
  243.         a[i   ] = (a[i] + xr);
  244.  
  245.         xr = a[i+4] * xp[1];
  246.         a[i+ 4] = (a[i+24] - xr);
  247.         a[i+24] = (a[i+24] + xr);
  248.  
  249.         xr = a[i+20] * xp[2];
  250.         a[i+20] = (a[i+8] - xr);
  251.         a[i+ 8] = (a[i+8] + xr);
  252.  
  253.         xr = a[i+12] * xp[3];
  254.         a[i+12] = (a[i+16] - xr);
  255.         a[i+16] = (a[i+16] + xr);
  256.     }
  257.     xp += 4;
  258.  
  259.     for (i = 0; i < 4; i++) {
  260.         FLOAT8 xr;
  261.  
  262.         xr = a[30-i*4] * xp[0];
  263.         a[30-i*4] = (a[i*4] - xr);
  264.         a[   i*4] = (a[i*4] + xr);
  265.  
  266.         xr = a[ 2+i*4] * xp[1];
  267.         a[ 2+i*4] = (a[28-i*4] - xr);
  268.         a[28-i*4] = (a[28-i*4] + xr);
  269.  
  270.         xr = a[31-i*4] * xp[0];
  271.         a[31-i*4] = (a[1+i*4] - xr);
  272.         a[ 1+i*4] = (a[1+i*4] + xr);
  273.  
  274.         xr = a[ 3+i*4] * xp[1];
  275.         a[ 3+i*4] = (a[29-i*4] - xr);
  276.         a[29-i*4] = (a[29-i*4] + xr);
  277.  
  278.         xp += 2;
  279.     }
  280.  
  281.     p0 = 30;
  282.     p1 = 1;
  283.     do {
  284.         FLOAT8 xr = a[p1] * *xp++;
  285.         a[p1] = (a[p0] - xr);
  286.         a[p0] = (a[p0] + xr);
  287.         p0 -= 2; p1 += 2;
  288.     } while (p0 >= 0);
  289.     }
  290. }
  291.  
  292. INLINE static void window_subband(short *x1, FLOAT8 a[SBLIMIT])
  293. {
  294.     int i;
  295.     FLOAT8 const *wp = enwindow;
  296.  
  297.     short *x2 = &x1[238-14-286];
  298.  
  299.     for (i = -15; i < 0; i++) {
  300.     FLOAT8 w, s, t;
  301.  
  302.     w = wp[ 0]; s  = x2[  32] * w; t  = x1[- 32] * w;
  303.     w = wp[ 1]; s += x2[  96] * w; t += x1[- 96] * w;
  304.     w = wp[ 2]; s += x2[ 160] * w; t += x1[-160] * w;
  305.     w = wp[ 3]; s += x2[ 224] * w; t += x1[-224] * w;
  306.     w = wp[ 4]; s += x2[-224] * w; t += x1[ 224] * w;
  307.     w = wp[ 5]; s += x2[-160] * w; t += x1[ 160] * w;
  308.     w = wp[ 6]; s += x2[- 96] * w; t += x1[  96] * w;
  309.     w = wp[ 7]; s += x2[- 32] * w; t += x1[  32] * w;
  310.  
  311.     w = wp[ 8]; s += x1[-256] * w; t -= x2[ 256] * w;
  312.     w = wp[ 9]; s += x1[-192] * w; t -= x2[ 192] * w;
  313.     w = wp[10]; s += x1[-128] * w; t -= x2[ 128] * w;
  314.     w = wp[11]; s += x1[- 64] * w; t -= x2[  64] * w;
  315.     w = wp[12]; s -= x1[   0] * w; t += x2[   0] * w;
  316.     w = wp[13]; s -= x1[  64] * w; t += x2[- 64] * w;
  317.     w = wp[14]; s -= x1[ 128] * w; t += x2[-128] * w;
  318.     w = wp[15]; s -= x1[ 192] * w; t += x2[-192] * w;
  319.     wp += 16;
  320.  
  321.     *--a = t;
  322.     a[(i+16)*2] = s;
  323.     x1--;
  324.     x2++;
  325.     }
  326.     {
  327.     FLOAT8 s,t;
  328.     t  =  x1[- 16] * wp[0];               s  = x1[ -32] * wp[ 8];
  329.     t += (x1[- 48] - x1[ 16]) * wp[1];    s += x1[ -96] * wp[ 9];
  330.     t += (x1[- 80] + x1[ 48]) * wp[2];    s += x1[-160] * wp[10];
  331.     t += (x1[-112] - x1[ 80]) * wp[3];    s += x1[-224] * wp[11];
  332.     t += (x1[-144] + x1[112]) * wp[4];    s -= x1[  32] * wp[12];
  333.     t += (x1[-176] - x1[144]) * wp[5];    s -= x1[  96] * wp[13];
  334.     t += (x1[-208] + x1[176]) * wp[6];    s -= x1[ 160] * wp[14];
  335.     t += (x1[-240] - x1[208]) * wp[7];    s -= x1[ 224] * wp[15];
  336.  
  337.     a[15] = t;
  338.     a[-1] = s;
  339.     }
  340. }
  341.  
  342.  
  343. /*-------------------------------------------------------------------*/
  344. /*                                                                   */
  345. /*   Function: Calculation of the MDCT                               */
  346. /*   In the case of long blocks (type 0,1,3) there are               */
  347. /*   36 coefficents in the time domain and 18 in the frequency       */
  348. /*   domain.                                                         */
  349. /*   In the case of short blocks (type 2) there are 3                */
  350. /*   transformations with short length. This leads to 12 coefficents */
  351. /*   in the time and 6 in the frequency domain. In this case the     */
  352. /*   results are stored side by side in the vector out[].            */
  353. /*                                                                   */
  354. /*   New layer3                                                      */
  355. /*                                                                   */
  356. /*-------------------------------------------------------------------*/
  357.  
  358. INLINE static void mdct_short(FLOAT8 *out, FLOAT8 *in)
  359. {
  360.     int l;
  361.     for ( l = 0; l < 3; l++ ) {
  362.     FLOAT tc0,tc1,tc2,ts0,ts1,ts2;
  363.  
  364.     ts0 = in[5];
  365.     tc0 = in[3];
  366.     tc1 = ts0 + tc0;
  367.     tc2 = ts0 - tc0;
  368.  
  369.     ts0 = in[2];
  370.     tc0 = in[0];
  371.     ts1 = ts0 + tc0;
  372.     ts2 =-ts0 + tc0;
  373.  
  374.     tc0 = in[4];
  375.     ts0 = in[1];
  376.  
  377.     out[3*0] = tc1 + tc0;
  378.     out[3*5] =-ts1 + ts0;
  379.  
  380.     tc2 = tc2 * 0.86602540378443870761;
  381.     ts1 = ts1 * 0.5 + ts0;
  382.     out[3*1] = tc2-ts1;
  383.     out[3*2] = tc2+ts1;
  384.  
  385.     tc1 = tc1 * 0.5 - tc0;
  386.     ts2 = ts2 * 0.86602540378443870761;
  387.     out[3*3] = tc1+ts2;
  388.     out[3*4] = tc1-ts2;
  389.  
  390.     in += 6; out++;
  391.     }
  392. }
  393.  
  394. INLINE static void mdct_long(FLOAT8 *out, FLOAT8 *in)
  395. {
  396. #define inc(x) in[17-(x)]
  397. #define ins(x) in[8-(x)]
  398.  
  399.     const FLOAT8 c0=0.98480775301220802032, c1=0.64278760968653936292, c2=0.34202014332566882393;
  400.     const FLOAT8 c3=0.93969262078590842791, c4=-0.17364817766693030343, c5=-0.76604444311897790243;
  401.     FLOAT8 tc1 = inc(0)-inc(8),tc2 = (inc(1)-inc(7))*0.86602540378443870761, tc3 = inc(2)-inc(6), tc4 = inc(3)-inc(5);
  402.     FLOAT8 tc5 = inc(0)+inc(8),tc6 = (inc(1)+inc(7))*0.5,                    tc7 = inc(2)+inc(6), tc8 = inc(3)+inc(5);
  403.     FLOAT8 ts1 = ins(0)-ins(8),ts2 = (ins(1)-ins(7))*0.86602540378443870761, ts3 = ins(2)-ins(6), ts4 = ins(3)-ins(5);
  404.     FLOAT8 ts5 = ins(0)+ins(8),ts6 = (ins(1)+ins(7))*0.5,                    ts7 = ins(2)+ins(6), ts8 = ins(3)+ins(5);
  405.     FLOAT8 ct,st;
  406.  
  407.     ct = tc5+tc7+tc8+inc(1)+inc(4)+inc(7);
  408.     out[0] = ct;
  409.  
  410.     ct = tc1*c0 + tc2 + tc3*c1 + tc4*c2;
  411.     st = -ts5*c4 + ts6 - ts7*c5 + ts8*c3 + ins(4);
  412.     out[1] = ct+st;
  413.     out[2] = ct-st;
  414.  
  415.     ct =  tc5*c3 + tc6 + tc7*c4 + tc8*c5 - inc(4);
  416.     st = ts1*c2 + ts2 + ts3*c0 + ts4*c1;
  417.     out[3] = ct+st;
  418.     out[4] = ct-st;
  419.  
  420.     ct = (tc1-tc3-tc4)*0.86602540378443870761;
  421.     st = (ts5+ts7-ts8)*0.5+ins(1)-ins(4)+ins(7);
  422.     out[5] = ct+st;
  423.     out[6] = ct-st;
  424.  
  425.     ct = -tc5*c5 - tc6 - tc7*c3 - tc8*c4 + inc(4);
  426.     st = ts1*c1 + ts2 - ts3*c2 - ts4*c0;
  427.     out[7] = ct+st;
  428.     out[8] = ct-st;
  429.  
  430.     ct = tc1*c1 - tc2 - tc3*c2 + tc4*c0;
  431.     st = -ts5*c5 + ts6 - ts7*c3 + ts8*c4 + ins(4);
  432.     out[ 9] = ct+st;
  433.     out[10] = ct-st;
  434.  
  435.     ct = (tc5+tc7+tc8)*0.5-inc(1)-inc(4)-inc(7);
  436.     st = (ts1-ts3+ts4)*0.86602540378443870761;
  437.     out[11] = ct+st;
  438.     out[12] = ct-st;
  439.  
  440.     ct = tc1*c2 - tc2 + tc3*c0 - tc4*c1;
  441.     st =  ts5*c3 - ts6 + ts7*c4 - ts8*c5 - ins(4);
  442.     out[13] = ct+st;
  443.     out[14] = ct-st;
  444.  
  445.     ct = -tc5*c4 - tc6 - tc7*c5 - tc8*c3 + inc(4);
  446.     st = ts1*c0 - ts2 + ts3*c1 - ts4*c2;
  447.     out[15] = ct+st;
  448.     out[16] = ct-st;
  449.  
  450.     st = ts5+ts7-ts8-ins(1)+ins(4)-ins(7);
  451.     out[17] = st;
  452. }
  453.  
  454. static const int order[] = {
  455.     0,  16,  8, 24,  4,  20,  12,  28,
  456.     2,  18, 10, 26,  6,  22,  14,  30,
  457.     1,  17,  9, 25,  5,  21,  13,  29,
  458.     3,  19, 11, 27,  7,  23,  15,  31
  459. };
  460.  
  461.  
  462.  
  463. void mdct_init48(lame_global_flags *gfp)
  464. {
  465.     int i, k;
  466.     FLOAT8 sq;
  467.  
  468.     /* prepare the aliasing reduction butterflies */
  469.     for (k = 0; k < 8; k++) {
  470.     /*
  471.       This is table B.9: coefficients for aliasing reduction
  472.       */
  473.     static const FLOAT8 c[8] = {
  474.         -0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142, -0.0037
  475.     };
  476.     sq = 1.0 + c[k] * c[k];
  477.     sq = sqrt(sq);
  478.     ca[k] = c[k] / sq;
  479.     cs[k] = 1.0 / sq;
  480.     }
  481.  
  482.     /* type 0*/
  483.     for (i = 0; i < 36; i++)
  484.     win[0][i] = sin(PI/36 * (i + 0.5));
  485.     /* type 1*/
  486.     for (i = 0; i < 18; i++) 
  487.     win[1][i] = win[0][i];
  488.     for (; i < 24; i++)
  489.     win[1][i] = 1.0;
  490.     for (; i < 30; i++)
  491.     win[1][i] = cos(PI/12 * (i + 0.5));
  492.     for (; i < 36; i++)
  493.     win[1][i] = 0.0;
  494.     /* type 3*/
  495.     for (i = 0; i < 36; i++)
  496.     win[3][i] = win[1][35 - i];
  497.  
  498.     /* swap window data*/
  499.     for (k = 0; k < 4; k++) {
  500.     FLOAT8 a;
  501.  
  502.     a = win[0][17-k];
  503.     win[0][17-k] = win[0][9+k];
  504.     win[0][9+k] = a;
  505.  
  506.     a = win[0][35-k];
  507.     win[0][35-k] = win[0][27+k];
  508.     win[0][27+k] = a;
  509.  
  510.     a = win[1][17-k];
  511.     win[1][17-k] = win[1][9+k];
  512.     win[1][9+k] = a;
  513.  
  514.     a = win[1][35-k];
  515.     win[1][35-k] = win[1][27+k];
  516.     win[1][27+k] = a;
  517.  
  518.     a = win[3][17-k];
  519.     win[3][17-k] = win[3][9+k];
  520.     win[3][9+k] = a;
  521.  
  522.     a = win[3][35-k];
  523.     win[3][35-k] = win[3][27+k];
  524.     win[3][27+k] = a;
  525.     }
  526.  
  527.     for (i = 0; i < NL; i++) {
  528.     win[0][i] *= cos((NL/4+0.5+i%9)*PI/NL) / SCALE/(NL/4);
  529.     win[1][i] *= cos((NL/4+0.5+i%9)*PI/NL) / SCALE/(NL/4);
  530.     win[3][i] *= cos((NL/4+0.5+i%9)*PI/NL) / SCALE/(NL/4);
  531.     }
  532.  
  533.     for (i = NL/2; i < NL; i++) {
  534.     win[0][i] *= -1;
  535.     win[1][i] *= -1;
  536.     win[3][i] *= -1;
  537.     }
  538.  
  539.     for (i = 0; i < NL/4; i++)
  540.     tantab_l[i] = tan((NL/4+0.5+i)*PI/NL);
  541.  
  542.     /* type 2(short)*/
  543.     for (i = 0; i < NS / 4; i++) {
  544.     FLOAT8 w2 = cos(PI / NS * (i + 0.5)) * (4.0/NS) / SCALE;
  545.     win[SHORT_TYPE][i] = tan(PI / NS * (i + 0.5));
  546.     tritab_s[i*2  ] = cos((0.5+2-i)*PI/NS) * w2;
  547.     tritab_s[i*2+1] = sin((0.5+2-i)*PI/NS) * w2;
  548.     }
  549. }
  550.  
  551. void mdct_sub48(lame_global_flags *gfp,
  552.     short *w0, short *w1,
  553.     FLOAT8 mdct_freq[2][2][576],
  554.     III_side_info_t *l3_side)
  555. {
  556.     int gr, k, ch;
  557.     short *wk;
  558.     static int init = 0;
  559.     lame_internal_flags *gfc=gfp->internal_flags;
  560.  
  561.     FLOAT8 work[18];
  562.  
  563.     if ( gfc->mdct_sub48_init == 0 ) {
  564.         gfc->mdct_sub48_init=1;
  565.     mdct_init48(gfp);
  566.     init++;
  567.     }
  568.  
  569.     wk = w0 + 286;
  570.     /* thinking cache performance, ch->gr loop is better than gr->ch loop */
  571.     for (ch = 0; ch < gfc->stereo; ch++) {
  572.     for (gr = 0; gr < gfc->mode_gr; gr++) {
  573.         int    band;
  574.         FLOAT8 *mdct_enc = &mdct_freq[gr][ch][0];
  575.         gr_info *gi = &(l3_side->gr[gr].ch[ch].tt);
  576.         FLOAT8 *samp = gfc->sb_sample[ch][1 - gr][0];
  577.  
  578.         for (k = 0; k < 18 / 2; k++) {
  579.         window_subband(wk, samp + 16);
  580.         idct32(samp);
  581.         window_subband(wk + 32, samp + 32+16);
  582.         idct32(samp+32);
  583.         samp += 64;
  584.         wk += 64;
  585.         /*
  586.          * Compensate for inversion in the analysis filter
  587.          */
  588.         for (band = 16-32; band < 0; band++)
  589.             samp[band] *= -1;
  590.         }
  591.  
  592.  
  593.         /* apply filters on the polyphase filterbank outputs */
  594.         /* bands <= gfc->highpass_band will be zeroed out below */
  595.         /* bands >= gfc->lowpass_band  will be zeroed out below */
  596.         if (gfc->filter_type==0) {
  597.               for (band=gfc->highpass_start_band;  band <= gfc->highpass_end_band; band++) { 
  598.           for (k=0; k<18; k++) 
  599.             gfc->sb_sample[ch][1-gr][k][order[band]]*=gfc->amp_highpass[band];
  600.           }
  601.               for (band=gfc->lowpass_start_band;  band <= gfc->lowpass_end_band; band++) { 
  602.           for (k=0; k<18; k++) 
  603.             gfc->sb_sample[ch][1-gr][k][order[band]]*=gfc->amp_lowpass[band];
  604.           }
  605.         }
  606.         
  607.  
  608.  
  609.         /*
  610.          * Perform imdct of 18 previous subband samples
  611.          * + 18 current subband samples
  612.          */
  613.         for (band = 0; band < 32; band++, mdct_enc += 18) 
  614.         {
  615.         int type = gi->block_type;
  616.         int band_swapped;
  617.         band_swapped = order[band];
  618. #ifdef ALLOW_MIXED
  619.         if (gi->mixed_block_flag && band < 2)
  620.             type = 0;
  621. #endif
  622.         if (band >= gfc->lowpass_band || band <= gfc->highpass_band) {
  623.             memset((char *)mdct_enc,0,18*sizeof(FLOAT8));
  624.         }else {
  625.           if (type == SHORT_TYPE) {
  626.             for (k = 2; k >= 0; --k) {
  627.             FLOAT8 win1 = win[SHORT_TYPE][k];
  628.             FLOAT8 a, b;
  629.  
  630.             a = gfc->sb_sample[ch][gr][k+6][band_swapped] * win1 -
  631.                 gfc->sb_sample[ch][gr][11-k][band_swapped];
  632.  
  633.             b = gfc->sb_sample[ch][gr][k+12][band_swapped] +
  634.                 gfc->sb_sample[ch][gr][17-k][band_swapped] * win1;
  635.  
  636.             work[k+3] = -b*tritab_s[k*2  ] + a * tritab_s[k*2+1];
  637.             work[k  ] =  b*tritab_s[k*2+1] + a * tritab_s[k*2  ];
  638.  
  639.             a = gfc->sb_sample[ch][gr][k+12][band_swapped] * win1 -
  640.                 gfc->sb_sample[ch][gr][17-k][band_swapped];
  641.  
  642.             b = gfc->sb_sample[ch][1-gr][k][band_swapped] +
  643.                 gfc->sb_sample[ch][1-gr][5-k][band_swapped] * win1;
  644.  
  645.             work[k+9] = -b*tritab_s[k*2  ] + a * tritab_s[k*2+1];
  646.             work[k+6] =  b*tritab_s[k*2+1] + a * tritab_s[k*2  ];
  647.  
  648.             a = gfc->sb_sample[ch][1-gr][k][band_swapped] * win1 -
  649.                 gfc->sb_sample[ch][1-gr][5-k][band_swapped];
  650.  
  651.             b = gfc->sb_sample[ch][1-gr][k+6][band_swapped] +
  652.                 gfc->sb_sample[ch][1-gr][11-k][band_swapped] * win1;
  653.  
  654.             work[k+15] = -b*tritab_s[k*2  ] + a * tritab_s[k*2+1];
  655.             work[k+12] =  b*tritab_s[k*2+1] + a * tritab_s[k*2  ];
  656.             }
  657.             mdct_short(mdct_enc, work);
  658.           } else {
  659.             for (k = -NL/4; k < 0; k++) {
  660.             FLOAT8 a, b;
  661.             a = win[type][k+27] * gfc->sb_sample[ch][1-gr][k+9][band_swapped]
  662.               + win[type][k+36] * gfc->sb_sample[ch][1-gr][8-k][band_swapped];
  663.             b = win[type][k+ 9] * gfc->sb_sample[ch][gr][k+9][band_swapped]
  664.               - win[type][k+18] * gfc->sb_sample[ch][gr][8-k][band_swapped];
  665.             work[k+ 9] = a - b*tantab_l[k+9];
  666.             work[k+18] = a*tantab_l[k+9] + b;
  667.             }
  668.  
  669.             mdct_long(mdct_enc, work);
  670.           }
  671.         }
  672.         
  673.         
  674.         /*
  675.           Perform aliasing reduction butterfly
  676.         */
  677.         if (type != SHORT_TYPE) {
  678.           if (band == 0)
  679.             continue;
  680.           for (k = 7; k >= 0; --k) {
  681.             FLOAT8 bu,bd;
  682.             bu = mdct_enc[k] * ca[k] + mdct_enc[-1-k] * cs[k];
  683.             bd = mdct_enc[k] * cs[k] - mdct_enc[-1-k] * ca[k];
  684.             
  685.             mdct_enc[-1-k] = bu;
  686.             mdct_enc[k]    = bd;
  687.           }
  688.         }
  689.           }
  690.     }
  691.     wk = w1 + 286;
  692.     if (gfc->mode_gr == 1) {
  693.         memcpy(gfc->sb_sample[ch][0], gfc->sb_sample[ch][1], 576 * sizeof(FLOAT8));
  694.     }
  695.     }
  696. }
  697.